/**
 * La classe GrapheValuee
 * @author Klelifa Sarah, Razavet Maël
 * @version 1.0
 */
package fr.eisti.ing1.projetgsiKlelifaRazavet.Graphe;

//imports nécessaires
import fr.eisti.ing1.projetgsiKlelifaRazavet.DataManager.DataManager;
import fr.eisti.ing1.projetgsiKlelifaRazavet.Objets.Personne;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;

public class GrapheValuee<T extends Comparable<T>> {
    //Déclaration des attributs

    private Set<AreteValuee<T>> ensembleArete;
    private List<Personne> utilisateurs;

    /**
     * constructeur initialisé
     */
    public GrapheValuee() {
        this.ensembleArete = new HashSet<AreteValuee<T>>();
        this.utilisateurs = new ArrayList<Personne>();
    }

    /**
     * Récupère la liste des utilisateurs du réseau social
     * @return utilisateurs : la liste des utilisateurs
     */
    public List<Personne> getUtilisateurs() {
        return utilisateurs;
    }

    /**
     * Récupère l'ensemble des liens entre les utilisateurs du réseau social
     * @return ensembleArete : l'ensemble des liens du réseaux social
     */
    public Set<AreteValuee<T>> getEnsembleArete() {
        return ensembleArete;
    }

    //methodes
    /**
     * Fonction qui permet d'evaluer un lien d'amitier
     * @param personne1 la personne voulant evalué le lien d'amitier
     * @param personne2 la personne etant evalué
     * @param evaluation
     */
    public void evaluer(Personne personne1, Personne personne2, int evaluation) {
        Boolean trouve;//permet d'indiquer a l'utilisateur un eventuel probleme dans l'evaluation
        trouve = false;
        //on parcours l'ensemble des aretes du graphe et si on trouve l'arete correspondante qui lit les deux personnes on modifie la note
        for (AreteValuee<T> ar : ensembleArete) {
            if (ar.getSommet1().equals(personne1) && ar.getSommet2().equals(personne2)) {
                ar.setEvaluation(evaluation);
                //on sauvegarde le changement pour affecter la base de donnéesS
                DataManager.update(personne1.getIdPersonne(), personne2.getIdPersonne(), evaluation);
                System.out.println("Vous venez de donner une note a votre amitié " + evaluation);
                trouve = true;
            }
        }
        if(!trouve){
            System.out.println("Vous n'êtes pas ami ");
        }
    }

    /**
     * Fonction qui ajoute un ami a la liste des propositions d'une personne
     * @param personne1 ami proposant son ajout dans la liste
     * @param personne2 personne dont sa liste est modifié
     */
    public void proposerAmi(Personne personne1, Personne personne2) {
        if (!existeLien(personne1, personne2)&&!personne2.getPropositionAmi().contains(personne1)) {
            personne2.getPropositionAmi().add(personne1);
            System.out.println(personne1.toString() + " Vous venez de demander en amis " + personne2.toString());
            //on sauvegarde l'ajout pour pouvoir l'appliquer a la base de donnée
            DataManager.create(personne1.getIdPersonne(), personne2.getIdPersonne());
        } else {
            System.out.println(personne1+" Vous êtes déjà amis/dans la proposition d'ami avec/de "+personne2);
        }
    }

    /**
     * Fonction qui permet de vérifier si il existe un lien entre deux personnes
     * @param personne1
     * @param personne2
     * @return vrai si il existe un lien, faux sinon
     */
    public Boolean existeLien(Personne personne1, Personne personne2) {
        Boolean lienExiste;
        lienExiste = false;
        //on parcourt toutes les aretes du graphe pour chercher un lien entre les deux personnes, si il existe on renvoit vrai
        for (AreteValuee<T> ar : ensembleArete) {
            lienExiste = ((ar.getSommet1().equals(personne1) && ar.getSommet2().equals(personne2)) || (ar.getSommet1().equals(personne2) && ar.getSommet2().equals(personne1))) || lienExiste;
        }
        return lienExiste;
    }

    /**
     * Fonction qui permet de refuser un ami proposé
     * @param personne1 personne refusant l'ami
     * @param personne2 personne s'etant proposé
     */
    public void refuserAmiProposer(Personne personne1, Personne personne2) {
        //si la liste de proposition d'ami contient la personne que l'on veut ajouter
        if (personne1.getPropositionAmi().contains(personne2)) {
            //on la suprprime de la liste de proposition
            personne1.getPropositionAmi().remove(personne2);
            //on sauvegarde la suppresson pour pouvoir l'appliquer a la base de donnée
            DataManager.delete(personne2.getIdPersonne(), personne1.getIdPersonne());
            System.out.println(" Vous venez de refuser en amis " + personne2.toString());
        }else{
            System.out.println(" Votre liste de proposition d'ami ne contient pas " + personne2.toString());
        }
    }

    /**
     * Fonction qui permet d'accepter un ami proposer
     * @param personne1 personne acceptant l'ami
     * @param personne2 personne s'etant proposé
     */
    public void accepterAmi(Personne personne1, Personne personne2) {
        boolean boolNonProposer;
        boolNonProposer = true;
        //si la liste de proposition d'ami contient la personne que l'on veut ajouter
        if (personne1.getPropositionAmi().contains(personne2)) {
            //on la suprprime de la liste de proposition et on ajoute un lien entre les deux personnes
            personne1.getPropositionAmi().remove(personne2);
            //on regarde qui est deja dans la graphe afin de savoir combien de sommet on ajoute
            for (AreteValuee<T> ar : this.ensembleArete) {
                if ((ar.getSommet1().equals(personne2) && ar.getSommet2().equals(personne1))) {
                    boolNonProposer = false;
                    System.out.println("Rentrer");
                }
            }
            if (!boolNonProposer) {
                DataManager.create(personne2.getIdPersonne(), personne1.getIdPersonne());
            }
            //on ajoute le lien entre les deux personnes
            this.ensembleArete.add(new AreteValuee<T>(personne1, personne2));
            this.ensembleArete.add(new AreteValuee<T>(personne2, personne1));
            //on sauvegarde l'ajout pour pouvoir l'appliquer a la base de donnée
            DataManager.create(personne1.getIdPersonne(), personne2.getIdPersonne());
            System.out.println(personne1.toString() + " viens d'accepter la demande d'ajout d'amis " + personne2.toString());
        }else{
            System.out.println("Votre liste de proposition d'ami ne contient pas " + personne2.toString());
        }
    }

    /**
     * Fonction qui permet de supprimer un ami de sa liste d'ami
     * @param personne1
     * @param personne2
     */
    public void supprimerAmi(Personne personne1, Personne personne2) {
        //instanciation d'un itérateur
        Iterator<AreteValuee<T>> it;
        it = ensembleArete.iterator();
        //on parcourt l'ensemble des aretes du graphe et si on trouve l'ami correspondant on le supprime
        while (it.hasNext()) {
            AreteValuee<T> ar = it.next();
            if ((ar.getSommet1().equals(personne1) && ar.getSommet2().equals(personne2)) || (ar.getSommet1().equals(personne2) && ar.getSommet2().equals(personne1))) {
                it.remove();
                System.out.println("Vous venez de supprimer " + ar.getSommet2().toString());
                //on sauvegarde la suppresson pour pouvoir l'appliquer a la base de donnée
                DataManager.delete(ar.getSommet1().getIdPersonne(), ar.getSommet2().getIdPersonne());
            }

        }
        if(!existeLien(personne1, personne2)){
            System.out.println("Vous n'êtes pas amis avec " + personne2.toString());
        }
    }

    /**
     * permet d'effectuer une recherche en fonction nom et/ou prénom
     * @param nom
     * @param prenom
     * @return personnes la liste de personne trouvée dans le graphe
     */
    public ArrayList<Personne> rechercheParNomPrenom(String nom, String prenom) {
        //Déclaration et initialisation de variables
        ArrayList<Personne> personnes = new ArrayList<Personne>();
        //instanciation d'un itérateur
        Iterator<Personne> it;
        it = utilisateurs.iterator();
        while (it.hasNext()) {
            Personne p = it.next();
            //si le nom et le prenom est non null
            if (nom != null && prenom != null) {
                //mise en place des comparateurs de chaine non sensibles a la casse
                int resultNom = p.getNom().compareToIgnoreCase(nom);
                int resultPrenom = p.getPrenom().compareToIgnoreCase(prenom);
                //si les parametres correspondent a la personne
                if (resultNom == 0 || resultPrenom == 0) {
                    //si on l'a pas déjà ajouté, on ajoute cette personne
                    if (!personnes.contains(p)) {
                        personnes.add(p);
                    }
                }
                //si le nom est null
            } else if (nom != null) {
                //mise en place des comparateurs de chaine non sensibles a la casse
                int resultNom = p.getNom().compareToIgnoreCase(nom);
                //si le nom correspond à un résultat
                if (resultNom == 0) {
                    //si on l'a pas déjà ajouté, on ajoute cette personne
                    if (!personnes.contains(p)) {
                        personnes.add(p);
                    }
                }
                //si le prenom est non null
            } else {
                //mise en place des comparateurs de chaine non sensibles a la casse
                int resultPrenom = p.getPrenom().compareToIgnoreCase(prenom);
                //si le prenom correspond à un résultat
                if (resultPrenom == 0) {
                    //si on l'a pas déjà ajouté, on ajoute cette personne
                    if (!personnes.contains(p)) {
                        personnes.add(p);
                    }
                }
            }
        }
        //si la liste de résultat est vide, on affiche un message
        if (personnes.isEmpty()) {
            System.out.println("Aucune correspondance");
        }
        //on retourne la liste de personnes répondant aux critères
        return personnes;
    }

    /**
     * permet de rechercher les personnes en fonction de leurs parcours
     * @param nom
     * @param ville
     * @param annee
     * @return personnes une liste de personne
     */
    public ArrayList<Personne> rechercheParcoursScolaireOuProfessionnel(String nom, String ville, int annee) {
        //Déclaration et initialisation de variables
        ArrayList<Personne> personnes = new ArrayList<Personne>();
        int resultNom = 0;
        int resultVille = 0;
        //instanciation d'un itérateur
        Iterator<Personne> it;
        it = utilisateurs.iterator();
        while (it.hasNext()) {
            Personne p = it.next();
            //si la liste d'études est non vide
            if (!p.getEtudes().isEmpty()) {
                for (int i = 0; i < p.getEtudes().size(); i++) {
                    //si le nom est non null
                    if (nom != null) {
                        //mise en place des comparateurs de chaine non sensibles a la casse
                        resultNom = p.getEtudes().get(i).getNomEtablissement().compareToIgnoreCase(nom);
                    } else {
                        //sinon le critere ne correspond pas a la personne
                        resultNom = -1;
                    }
                    //si la ville est non null
                    if (ville != null) {
                        //mise en place des comparateurs de chaine non sensibles a la casse
                        resultVille = p.getEtudes().get(i).getAdresse().getVille().compareToIgnoreCase(ville);
                    } else {
                        //sinon le critere ne correspond pas a la personne
                        resultVille = -1;
                    }
                    //si la date de fin est non null(si la date de fin est anterieure a aujourdhui)
                    if (p.getEtudes().get(i).getDateFin() != null) {
                        //si le nom est null mais pas la ville on compare sur la ville et lannee
                        if (nom == null && ville != null) {
                            if (resultVille == 0 && annee <= p.getEtudes().get(i).getDateFin().get(Calendar.YEAR) && annee >= p.getEtudes().get(i).getDateDebut().get(Calendar.YEAR)) {
                                //si on l'a pas déjà ajouté, on ajoute cette personne
                                if (!personnes.contains(p)) {
                                    personnes.add(p);
                                }
                            }
                        //si la ville est null mais le nom alors on compare sur le nom et lannee
                        } else if (ville == null && nom != null) {
                            if (resultNom == 0 && annee <= p.getEtudes().get(i).getDateFin().get(Calendar.YEAR) && annee >= p.getEtudes().get(i).getDateDebut().get(Calendar.YEAR)) {
                                //si on l'a pas déjà ajouté, on ajoute cette personne
                                if (!personnes.contains(p)) {
                                    personnes.add(p);
                                }
                            }
                        //si la ville et le nom sont non null alors on compare sur tous les parametres
                        } else if (ville != null && nom != null) {
                            if (resultNom == 0 && (resultVille == 0 || annee <= p.getEtudes().get(i).getDateFin().get(Calendar.YEAR) && annee >= p.getEtudes().get(i).getDateDebut().get(Calendar.YEAR))) {
                                //si on l'a pas déjà ajouté, on ajoute cette personne
                                if (!personnes.contains(p)) {
                                    personnes.add(p);
                                }
                            }
                        }
                    } else {
                        //si le nom est null mais pas la ville on compare sur la ville et lannee
                        if (nom == null && ville != null) {
                            if (resultVille == 0 && annee >= p.getEtudes().get(i).getDateDebut().get(Calendar.YEAR)) {
                                //si on l'a pas déjà ajouté, on ajoute cette personne
                                if (!personnes.contains(p)) {
                                    personnes.add(p);
                                }
                            }
                        //si la ville est null mais le nom alors on compare sur le nom et lannee
                        } else if (ville == null && nom != null) {
                            if (resultNom == 0 && annee >= p.getEtudes().get(i).getDateDebut().get(Calendar.YEAR)) {
                                //si on l'a pas déjà ajouté, on ajoute cette personne
                                if (!personnes.contains(p)) {
                                    personnes.add(p);
                                }
                            }
                         //si la ville et le nom sont non null alors on compare sur tous les parametres
                        } else if (ville != null && nom != null) {
                            if (resultNom == 0 && (resultVille == 0 || annee >= p.getEtudes().get(i).getDateDebut().get(Calendar.YEAR))) {
                                //si on l'a pas déjà ajouté, on ajoute cette personne
                                if (!personnes.contains(p)) {
                                    personnes.add(p);
                                }
                            }
                        }
                    }
                }
            }
            //si la liste de travail est non vide
            if (!p.getTravailles().isEmpty()) {
                for (int i = 0; i < p.getTravailles().size(); i++) {
                    //si le nom est non null
                    if (nom != null) {
                        //on compare le parametre a l'attribut de la personne
                        resultNom = p.getTravailles().get(i).getNomEtablissement().compareToIgnoreCase(nom);
                    } else {
                        //sinon le critere ne correspond pas a la personne
                        resultNom = -1;
                    }
                    //si la ville est non null
                    if (ville != null) {
                        //on compare le parametre a l'attribut de la personne
                        resultVille = p.getTravailles().get(i).getAdresse().getVille().compareToIgnoreCase(ville);
                    } else {
                        //sinon le critere ne correspond pas a la personne
                        resultVille = -1;
                    }
                    //si la date de fin est non null(si la date de fin est anterieure a aujourdhui)
                    if (p.getTravailles().get(i).getDateFin() != null) {
                        //si le nom est null mais pas la ville on compare sur la ville et lannee
                        if (nom == null && ville != null) {
                            if (resultVille == 0 && annee <= p.getTravailles().get(i).getDateFin().get(Calendar.YEAR) && annee >= p.getTravailles().get(i).getDateDebut().get(Calendar.YEAR)) {
                                //si on l'a pas déjà ajouté, on ajoute cette personne
                                if (!personnes.contains(p)) {
                                    personnes.add(p);
                                }
                            }
                        //si la ville est null mais le nom alors on compare sur le nom et lannee
                        } else if (ville == null && nom != null) {
                            if (resultNom == 0 && annee <= p.getTravailles().get(i).getDateFin().get(Calendar.YEAR) && annee >= p.getTravailles().get(i).getDateDebut().get(Calendar.YEAR)) {
                                //si on l'a pas déjà ajouté, on ajoute cette personne
                                if (!personnes.contains(p)) {
                                    personnes.add(p);
                                }
                            }
                         //si la ville et le nom sont non null alors on compare sur tous les parametres
                        } else if (ville != null && nom != null) {
                            if (resultNom == 0 && (resultVille == 0 || annee <= p.getTravailles().get(i).getDateFin().get(Calendar.YEAR) && annee >= p.getTravailles().get(i).getDateDebut().get(Calendar.YEAR))) {
                                //si on l'a pas déjà ajouté, on ajoute cette personne
                                if (!personnes.contains(p)) {
                                    personnes.add(p);
                                }
                            }
                        }
                    } else {
                        //si le nom est null mais pas la ville on compare sur la ville et lannee
                        if (nom == null && ville != null) {
                            if (resultVille == 0 && annee >= p.getTravailles().get(i).getDateDebut().get(Calendar.YEAR)) {
                                //si on l'a pas déjà ajouté, on ajoute cette personne
                                if (!personnes.contains(p)) {
                                    personnes.add(p);
                                }
                            }
                        //si la ville est null mais le nom alors on compare sur le nom et lannee
                        } else if (ville == null && nom != null) {
                            if (resultNom == 0 && annee >= p.getTravailles().get(i).getDateDebut().get(Calendar.YEAR)) {
                                //si on l'a pas déjà ajouté, on ajoute cette personne
                                if (!personnes.contains(p)) {
                                    personnes.add(p);
                                }
                            }
                         //si la ville et le nom sont non null alors on compare sur tous les parametres
                        } else if (ville != null && nom != null) {
                            if (resultNom == 0 && (resultVille == 0 || annee >= p.getTravailles().get(i).getDateDebut().get(Calendar.YEAR))) {
                                //si on l'a pas déjà ajouté, on ajoute cette personne
                                if (!personnes.contains(p)) {
                                    personnes.add(p);
                                }
                            }
                        }
                    }
                }
            }
        }
        //si la liste de résultat est vide, on affiche un message
        if (personnes.isEmpty()) {
            System.out.println("Aucune correspondance");
        }
        //on retourne la liste de personnes répondant aux critères
        return personnes;
    }

    /**
     * recherche les personnes par centres d'intérêts
     * @param categorie
     * @param libelle
     * @return personnes la liste de personne trouvée dans le graphe
     */
    public ArrayList<Personne> rechercheParCentreInteret(String categorie, String libelle) {
        //Déclaration et initialisation de variables
        ArrayList<Personne> personnes = new ArrayList<Personne>();
        //instanciation d'un itérateur
        Iterator<Personne> it;
        it = utilisateurs.iterator();
        //tant qu'il y a des arêtes
        while (it.hasNext()) {
            Personne p = it.next();
            //si la liste des centre d'interet est vide
            if (!p.getCentreInterets().isEmpty()) {
                //on la parcourt
                for (int i = 0; i < p.getCentreInterets().size(); i++) {
                    //si les parametres sont non null
                    if (categorie != null && libelle != null) {
                        //mise en place des comparateurs de chaine non sensibles a la casse
                        int result = p.getCentreInterets().get(i).getCategorie().compareToIgnoreCase(categorie);
                        int result2 = p.getCentreInterets().get(i).getNomCentreInteret().compareToIgnoreCase(libelle);
                        if (result == 0 || result2 == 0) {
                            //si on l'a pas déjà ajouté, on ajoute cette personne
                            if (!personnes.contains(p)) {
                                personnes.add(p);
                            }
                        }
                    } else if (categorie != null && libelle == null) {
                        //mise en place des comparateurs de chaine non sensibles a la casse
                        int result = p.getCentreInterets().get(i).getCategorie().compareToIgnoreCase(categorie);
                        if (result == 0) {
                            //si on l'a pas déjà ajouté, on ajoute cette personne
                            if (!personnes.contains(p)) {
                                personnes.add(p);
                            }
                        }
                    } else {
                        //mise en place des comparateurs de chaine non sensibles a la casse
                        int result2 = p.getCentreInterets().get(i).getNomCentreInteret().compareToIgnoreCase(libelle);
                        if (result2 == 0) {
                            //si on l'a pas déjà ajouté, on ajoute cette personne
                            if (!personnes.contains(p)) {
                                personnes.add(p);
                            }
                        }
                    }

                }
            }
        }
        //si la liste de résultat est vide, on affiche un message
        if (personnes.isEmpty()) {
            System.out.println("Aucune correspondance");
        }
        //on retourne la liste de personnes répondant aux critères
        return personnes;
    }

    /**
     * permet de retrouver les successeurs de p
     * @param p une personne
     * @return personnes la liste des successeurs de p
     */
    public ArrayList<Personne> recSuccesseurs(Personne p) {
        //Déclaration et initialisation de variables
        ArrayList<Personne> personnes = new ArrayList<Personne>();
        //instanciation des itérateurs nécessaires
        Iterator<AreteValuee<T>> it;
        it = this.ensembleArete.iterator();

        //on parcours la liste d'arete
        while (it.hasNext()) {
            AreteValuee<T> ar = it.next();
            if (!personnes.contains(ar.getSommet1()) || !personnes.contains(ar.getSommet2())) {
                if (ar.getSommet1() == p) {
                    //si on l'a pas déjà ajouté, on ajoute cette personne
                    if (!personnes.contains(ar.getSommet2())) {
                        personnes.add(ar.getSommet2());
                        it.remove();
                    }
                }
                if (ar.getSommet2() == p) {
                    //si on l'a pas déjà ajouté, on ajoute cette personne
                    if (!personnes.contains(ar.getSommet1())) {
                        personnes.add(ar.getSommet1());
                        it.remove();
                    }
                }

            }
        }
        //si la liste de résultat est vide, on affiche un message
        if (personnes == null) {
            System.out.println("Aucune correspondance");
        }
        //on retourne la liste de personnes répondant aux critères
        return personnes;
    }

    /**
     * fonction qui permet de rechercher les amis d'amis avec une limite en nombe d'amis
     * @param origine la racine (personne)
     * @param personnes une liste temporaire d'amis des amis
     * @param nbAmis la limite d'amis que l'ont s'est fixé
     * @return personnes la liste d'amis des amis
     */
    public ArrayList<Personne> rechercheParAmi(Personne origine, ArrayList<Personne> personnes, int nbAmis) {
        //Déclaration et initialisation des variables
        boolean bool = false;//booleen pour savoir si on a terminé le parcours
        //tant qu'on n'a pas atteint le nombre d'amis rentré en paramètres
        while (nbAmis > 0 && !bool) {
            //booléen est vrai
            bool = true;
            //on parcours la liste de successeurs
            for (Personne p : recSuccesseurs(origine)) {
                //si la personne n'est pas encore stockée dans la liste et que la limite d'amis n'est pas atteinte et que p est différent d'origine
                //et que les successeurs d'origine contiennent bien p
                if (!(personnes.contains(p)) && !(p.equals(origine)) && !(recSuccesseurs(origine).contains(p)) && nbAmis > 0) {
                    //on ajoute la personne dans la liste de résultat
                    personnes.add(p);
                    //on décremente le nombre d'amis
                    nbAmis = nbAmis - 1;
                    //on n'a pas terminé le parcours
                    bool = false;
                    //on appelle la fonction auxiliaire avec les successeurs de origine
                    personnes = rechercheParAmis(origine, p, personnes, nbAmis);
                }
                //si la racine est égale à notre personnes temporaire
                if (origine.equals(origine)) {
                    //on appelle la fonction auxiliaire avec les successeurs de origine et avec nbAmis-1
                    personnes = rechercheParAmis(origine, p, personnes, nbAmis - 1);
                }
            }
        }
        //si la liste de résultat est vide, on affiche un message
        if (personnes.isEmpty()) {
            System.out.println("Aucune correspondance");
        }
        //on retourne la liste de personnes répondant aux critères
        return personnes;
    }

    /**
     * fonction qui permet de rechercher les amis d'amis avec une limite en nombe d'amis
     * @param origine la racine (personne)
     * @param pTmp une personne temporaire
     * @param personnes une liste temporaire d'amis des amis
     * @param nbAmis la limite d'amis que l'ont s'est fixé
     * @return personnes la liste d'amis des amis
     */
    public ArrayList<Personne> rechercheParAmis(Personne origine, Personne pTmp, ArrayList<Personne> personnes, int nbAmis) {
        //Déclaration et initialisation des variables
        boolean bool = false;//booleen pour savoir si on a terminé le parcours
        //tant qu'on n'a pas atteint le nombre d'amis rentré en paramètres
        while (nbAmis > 0 && !bool) {
            //booléen est vrai
            bool = true;
            //on parcours la liste de successeurs
            for (Personne p : recSuccesseurs(pTmp)) {
                //si la personne n'est pas encore stockée dans la liste et que la limite d'amis n'est pas atteinte et que p est différent d'origine
                //et que les successeurs d'origine contiennent bien p
                if (!(personnes.contains(p)) && !(p.equals(origine)) && !(recSuccesseurs(origine).contains(p)) && nbAmis > 0) {
                    //on ajoute la personne dans la liste de résultat
                    personnes.add(p);
                    //on décremente le nombre d'amis
                    nbAmis = nbAmis - 1;
                    //on n'a pas terminé le parcours
                    bool = false;
                    //on appelle la fonction auxiliaire avec les successeurs de origine
                    personnes = rechercheParAmis(origine, p, personnes, nbAmis);
                }
                //si la racine est égale à notre personnes temporaire
                if (origine.equals(pTmp)) {
                    //on appelle la fonction auxiliaire avec les successeurs de origine
                    personnes = rechercheParAmis(origine, p, personnes, nbAmis);
                }
            }
        }
        //on retourne la liste de personnes répondant aux critères
        return personnes;
    }

    /**
     * permet de stocker toutes les personnes du réseau dans une liste
     * @return personnes la liste de toutes les personnes du réseau
     */
    public ArrayList<Personne> trouverToutesLesPersonnes() {
        //Déclaration et initialisation de variables
        ArrayList<Personne> personnes = new ArrayList<Personne>();
        //instanciation des itérateurs nécessaires
        Iterator<AreteValuee<T>> it;
        it = this.ensembleArete.iterator();

        //on parcours la liste d'arete
        while (it.hasNext()) {
            AreteValuee<T> ar = it.next();
            //si on l'a pas déjà ajouté, on ajoute cette personne
            if (!personnes.contains(ar.getSommet1())) {
                personnes.add(ar.getSommet1());
            }
            //si on l'a pas déjà ajouté, on ajoute cette personne
            if (!personnes.contains(ar.getSommet2())) {
                personnes.add(ar.getSommet2());
            }
        }
        //si la liste de résultat est vide, on affiche un message
        if (personnes.isEmpty()) {
            System.out.println("Aucune correspondance");
        }
        //on retourne la liste de personnes répondant aux critères
        return personnes;
    }

    /**
     * représentation textuelle du graphe
     * @return la représentation textuelle
     */
    @Override
    public String toString() {
        //déclaration et initialisation des variables
        String res = "";
        //on parcours l'ensemble d'arete du graphe
        for (AreteValuee<T> ar : this.ensembleArete) {
            //on stocke dans res les représentations textuelles des aretes du graphe
            res = res + " " + ar.toString() + "\n";
        }
        //on retourne res
        return res;
    }
}
